
// using System.Collections;
// using System.Collections.Generic;
// using System.Net.Sockets;
// using System.Net;
// using System;
// using Newtonsoft.Json;  //引用命名空间
// using System.Linq;

// // NetManager定义
// public static class NetManager
// {
//     static bool debug = false;
//     static Socket socket;
//     static int len_readbuff = 1024;
//     // static byte[] readBuff = new byte[len_readbuff];
//     static ByteArray readBuff = new ByteArray(len_readbuff);
//     // static int buffCount = 0;  // 记录有多长, 已被`ByteArray.length`取代

//     static int head_len = 2;  // 消息头的长度, int16则为2字节, int32则4字节
//     // static string recvStr = "";

//     static int len_sendbytes = 1024;
//     static byte[] sendBytes = new byte[len_sendbytes];
//     // static int readIdx = 0;  // 缓冲区偏移值
//     // static int length = 0;  // 缓冲区剩余长度

//     static Queue<ByteArray> writeQueue = new Queue<ByteArray>();

//     // 委托类型
//     public delegate void MsgListener(String str);

//     // 监听列表
//     private static Dictionary<string, MsgListener> listeners = new Dictionary<string, MsgListener>();

//     static List<String> msgList = new List<string>();

//     // 添加监听
//     public static void AddListener(string msgName, MsgListener listener)
//     {
//         // Debug.Log("add_listener---" + msgName);
//         listeners[msgName] = listener;
//     }

//     // 获取描述
//     public static string GetDesc()
//     {
//         if (socket == null) return "";
//         if (!socket.Connected) return "";
//         return socket.LocalEndPoint.ToString();
//     }

//     // 连接
//     public static void Connect(string ip, int port)
//     {
//         // Socket
//         socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
//         // 绑定端口
//         // int bind_port = BdUtils.TimeUtils.get_random_number(8800, 8900);
//         // socket.Bind(new IPEndPoint(IPAddress.Parse("127.0.0.1"), bind_port));
//         // Connect (用同步方式简化代码)
//         socket.Connect(ip, port);

//         // BeginRecieve
//         // socket.BeginReceive(readBuff, 0, len_readbuff, 0, ReceiveCallback, socket);
//         // socket.BeginReceive(readBuff, buffCount, len_readbuff - buffCount, 0, ReceiveCallback, socket);
//         socket.BeginReceive(readBuff.bytes, readBuff.writeIdx, readBuff.remain, 0, ReceiveCallback, socket);
//         Debug.Log("--- 成建立功连接: " + ip + ':' + port);
//     }

//     public static void Close()
//     {
//         socket.Close();
//     }

//     // Receive回调
//     private static void ReceiveCallback(IAsyncResult ar)
//     {
//         try
//         {
//             Socket socket = (Socket)ar.AsyncState;
//             int count = socket.EndReceive(ar);  // 获取接收数据的长度

//             BdUtils.log($"count --- {count}");
//             // BdUtils.TimeUtils.sleep(0.01);

//             readBuff.writeIdx += count;
//             OnReceiveData();

//             // 继续接受数据
//             if (readBuff.remain < 8)
//             {
//                 readBuff.MoveBytes();
//                 readBuff.Resize(readBuff.length * 2);
//             }
//             socket.BeginReceive(readBuff.bytes, readBuff.writeIdx, readBuff.remain, 0, ReceiveCallback, socket);

//             // buffCount += count;  // 获取缓存数据长度
//             // buffCount = buffCount <= len_readbuff ? buffCount : len_readbuff;

//             // OnReceiveData(); // 处理二进制数据

//             // // Debug.Log("~~~Count " + msgList.Count);   // dbg
//             // socket.BeginReceive(readBuff, 0, len_readbuff, 0, ReceiveCallback, socket);
//         }
//         catch (SocketException ex)
//         {
//             string e = "Socket Receive fail " + ex.ToString();
//             // Debug.Log(e);
//             // socket.Close();
//             BdUtils.assert(0, e);
//         }
//     }

//     public static void OnReceiveData()
//     {
//         BdUtils.log("\n\n ====== Start Receive ======");
//         BdUtils.log($"[Recv 1] length = {readBuff.length}");
//         BdUtils.log($"[Recv 2] readBuff = {readBuff}");
//         // BdUtils.log($"[Recv 2] readBuff = {System.Text.Encoding.UTF8.GetString(readBuff)}");

//         // // 获取缓冲区中可供读取的字节数
//         // int available = socket.Available;
//         // BdUtils.log($"[Recv 2.5] available = {available}");

//         // 消息长度
//         if (readBuff.length <= head_len)
//             return;

//         // 解析bodyLength
//         // Int32 bodyLength = BitConverter.ToInt32(readBuff, 0);
//         // Int16 bodyLength = BitConverter.ToInt16(readBuff, 0);

//         // int readIdx = readBuff.readIdx;
//         // byte[] bytes = readBuff.bytes;
//         // Int16 bodyLength = (Int16)((bytes[readIdx + 1] << 8 | bytes[readIdx]));
//         // readIdx += 2;
//         // readBuff.CheckAndMoveBytes();

//         Int16 bodyLength = readBuff.ReadInt16();

//         BdUtils.log($"[Recv 3] bodyLength = {bodyLength}");

//         if (bodyLength < 0)
//         {
//             BdUtils.log($"*** 出现bodyLength[{bodyLength}]值错误的情况!");
//             BdUtils.log($"[此时的缓冲区] readBuff = {System.Text.Encoding.UTF8.GetString(readBuff.bytes)}");
//             return;
//         }

//         // 消息体
//         if (bodyLength > readBuff.length)
//         {
//             BdUtils.log($"--- 返回原因: bodyLength[{bodyLength}] > readBuff.length[{readBuff.length}]");
//             // BdUtils.log($"--- 返回: bodyLength[{bodyLength}] <  head_len[{head_len}] + bodyLength[{bodyLength}]");
//             BdUtils.log($"[此时的缓冲区] readBuff = {System.Text.Encoding.UTF8.GetString(readBuff.bytes)}");
//             readBuff.readIdx -= 2;
//             return;
//         }

//         // string s = System.Text.Encoding.UTF8.GetString(readBuff, head_len, bodyLength);
//         byte[] stringByte = new byte[bodyLength];
//         readBuff.Read(stringByte, 0, bodyLength);
//         string recvStr = System.Text.Encoding.UTF8.GetString(stringByte);
//         BdUtils.log($"[Recv 4] --- recvStr = {recvStr}");
//         BdUtils.log($"[Recv 2] readBuff = {readBuff}");

//         // // 更新缓冲区
//         // int start = head_len + bodyLength;
//         // // int count = buffCount - start;
//         // int count = buffCount <= len_readbuff ? buffCount - start : len_readbuff - start;

//         // // count = count < len_readbuff ? count : len_readbuff - start;
//         // BdUtils.log($"=== start: {start} --- count: {count}");
//         // Array.Copy(readBuff, start, readBuff, 0, count);

//         // buffCount -= start;
//         // BdUtils.log($"[Recv 5] buffCount = {buffCount} --- readBuff.Length: {readBuff.Length}");
//         // // BdUtils.log($"[Recv 5] readBuff = {System.Text.Encoding.UTF8.GetString(readBuff)}");

//         // 消息处理
//         msgList.Add(recvStr);

//         // // 继续读取消息
//         // OnReceiveData();

//         //继续读取消息
//         if (readBuff.length > head_len)
//         {
//             OnReceiveData();
//         }

//     }

//     // 发送
//     public static void Send(string sendStr)
//     {
//         if (socket == null) return;
//         if (!socket.Connected) return;


//         // byte[] sendBytes = System.Text.Encoding.UTF8.GetBytes(sendStr);  // 直接发送

//         // 长度信息1 bodyLength
//         byte[] bodyBytes = System.Text.Encoding.UTF8.GetBytes(sendStr);
//         Int16 len = (Int16)bodyBytes.Length;
//         // Int32 len = (Int32)bodyBytes.Length;
//         byte[] lenBytes = BitConverter.GetBytes(len);
//         if (!BitConverter.IsLittleEndian)
//         {
//             BdUtils.log("[Send] Reverse lenBytes");
//             lenBytes.Reverse();
//         }
//         byte[] sendBytes = lenBytes.Concat(bodyBytes).ToArray();

//         // 长度信息法2
//         // byte[] lenBytes = BitConverter.GetBytes(sendStr.Length);
//         // byte[] sendBytes = lenBytes.Concat(System.Text.Encoding.UTF8.GetBytes(sendStr)).ToArray();

//         // byte[] sendBytes = System.Text.Encoding.Default.GetBytes(bodyBytes);

//         // BdUtils.log($"sendBytes ----", sendBytes);

//         // socket.Send(sendBytes);
//         // socket.BeginSend(sendBytes, 0, sendBytes.Length, 0, SendCallback, socket);

//         ByteArray ba = new ByteArray(sendBytes);
//         int count = 0;
//         // 这里实现`完整发送数据`的功能
//         lock (writeQueue)
//         {
//             writeQueue.Enqueue(ba);
//             count = writeQueue.Count;
//         }

//         if (writeQueue.Count == 1)
//         {
//             socket.BeginSend(ba.bytes, ba.readIdx, ba.length, 0, SendCallback, socket);
//         }

//         // --- 旧版完整发送数据
//         // length = sendBytes.Length;
//         // readIdx = 0;
//         // socket.BeginSend(sendBytes, 0, length, 0, SendCallback, socket);
//     }
//     public static void Send(object sendStr)
//     {
//         Send(sendStr.ToString());
//     }


//     public static void SendCallback(IAsyncResult ar)
//     {
//         try
//         {
//             Socket socket = (Socket)ar.AsyncState;
//             int count = socket.EndSend(ar);

//             ByteArray ba;

//             // 判断是否发送完整
//             lock (writeQueue)
//             {
//                 ba = writeQueue.First();
//             }
//             ba.readIdx += count;

//             if (ba.length == 0)  // 发送完整
//             {
//                 lock (writeQueue)
//                 {
//                     writeQueue.Dequeue();
//                     if (writeQueue.Count() != 0)
//                     {
//                         ba = writeQueue.First();
//                     }
//                     else
//                         ba = null;
//                 }

//             }
//             if (ba != null)  // 发送不完整, 或者发送完整且存在第二条数据
//             {
//                 BdUtils.log($"--- ba | readIdx[{ba.readIdx}] | length[{ba.length}]");
//                 socket.BeginSend(ba.bytes, ba.readIdx, ba.length, 0, SendCallback, socket);
//             }

//             // readIdx += count;
//             // length -= count;

//             // if (length > 0)
//             // {
//             //     socket.BeginSend(sendBytes, readIdx, length, 0, SendCallback, socket);
//             // }

//             // Debug.Log("Socket Send succ" + count);
//         }
//         catch (SocketException ex)
//         {
//             Debug.Log("Socket Send fail" + ex.ToString());
//         }
//     }

//     // Update
//     public static void Update()
//     {
//         BdUtils.log($"~~~ NetManager.Update at {BdUtils.TimeUtils.get_time_string("s2", get_date: false)}");

//         if (msgList.Count <= 0) return;
//         String msgStr = msgList[0];
//         // BdUtils.log($"*** Update received msgStr: {msgStr}");

//         msgList.RemoveAt(0);

//         MsgHandle.run_method_by_msg(msgStr);  // 使用`MsgHandle`类
//     }
// }
